home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / XCMD libraries 960603 / xcmdStrings.cp < prev    next >
Text File  |  1996-05-29  |  9KB  |  407 lines
  1. #include <UException.h>
  2. //    © Paul B. Beeken, Work In Progress, 1994-5
  3. //    Knowledge Software Consulting.
  4. //
  5. //    These files are a mindlessly simple wrapper class for the
  6. //    basic XCMD operations.  Only one instance of the xcmdBase class is
  7. //    generated per XCMD call but there may be many instances of the XCMDString
  8. //    class.  I have used these classes to whip out XCMD/XFCNs within hours of
  9. //    receiving the specs.  They work great for me but I will always consider 
  10. //    suggestions.
  11. //
  12. //    Please, please, please, in the unlikely event you should use this stuff
  13. //    for some commercial application I would appreciate you contacting me.  If
  14. //    its for your own use, use away. Send email: knowsoft@ios.com
  15. //
  16. //    As always: this file is presented as is with no warrantees expressed or implied.
  17. //    Swim at your own risk, etc. etc.
  18. //
  19. //    A serious improvement over the previous version.
  20. //    11/11/95    because of some problems with stricter type checking under
  21. //               CW 7 I have changed the scheme for string storage.  I 
  22. //               allocate a single storage pointer which will hold the pascal 
  23. //               length byte and the null terminator.  If I need a c string I 
  24. //               simply pass a pointer to the beginning of the c like 
  25. //               portion.  A pascal string request gets a pointer to the very 
  26. //               beginning.  Designing this way required more attention to 
  27. //               details over the previous brain-dead method.
  28. //  05/28/96    CW9 made some changes to <HyperXCmd.h> I've incorporated those changes
  29. //                 here.
  30. //#include    <strings.h>
  31. #include    "xcmdStrings.h"
  32.  
  33. const    int MAX_PSIZE    = 255;
  34.  
  35. #define NoCLIB 1
  36.  
  37. #ifdef NoCLIB
  38. //    A local function to avoid need for clib;
  39. int
  40. strlen( char* a );
  41. int
  42. strlen( char* a )
  43. {
  44.     int i=0;
  45.     for( ; *a; a++ ) i++;
  46.     return i;
  47. }
  48.  
  49. void
  50. strcpy( char* a, char* b );
  51. void
  52. strcpy( char* a, char* b )
  53. {
  54.     for( ; *b; b++,a++ ) *a = *b;
  55.     *a = *b;
  56. }
  57.  
  58. void
  59. strncpy( char* a, char* b, int i );
  60. void
  61. strncpy( char* a, char* b, int i )
  62. {
  63.     for( ; i; b++,a++,i-- ) *a = *b;
  64.     //*a = '\0';
  65. }
  66.  
  67. char*
  68. strcat( char* a, char* b );
  69. char*
  70. strcat( char* a, char* b )
  71. {
  72.     char*    c = a;
  73.     while( *a++ ) {}
  74.     --a;    // we've overstepped, backup one.
  75.     for( ; *b; b++,a++ ) *a = *b;
  76.     *a = *b;
  77.     return c;
  78. }
  79. #else
  80. #include    <string.h>
  81. #endif
  82.  
  83. // allocated when xcmdBase object is instantiated
  84. XCmdPtr    
  85. xcmdString::paramPtr    = nil;
  86.  
  87. // I could calculate this once for each instantiation but
  88. //    I don't often need it.  Calculate when needed.
  89. int
  90. xcmdString::length( void ) const
  91. {
  92.     return len;        // The string length.
  93. }
  94.  
  95. //    Wipe pointer, return storage.
  96. xcmdString::~xcmdString()
  97. {
  98.     if ( str != nil )    delete [] str;
  99. }
  100.  
  101. xcmdString::xcmdString() : len(0)
  102. {
  103.     str = nil;
  104. }
  105.  
  106. #pragma    mark -
  107. #pragma mark • Creation Operators…
  108. // from null length handle.
  109. xcmdString::xcmdString( Handle s, Boolean useHandLen )
  110. {
  111.     if ( useHandLen ) 
  112.         len = ::GetHandleSize( s );
  113.     else
  114.         len = strlen(*s);
  115.     
  116.     str = new char[len+2];
  117.         ThrowIfNil_( str );
  118. //    HLock( s );
  119. //    strcpy( cStr(), *s );
  120.     strncpy( cStr(), *s, len+1 );
  121. //    HUnlock( s );
  122.     str[0] = len>MAX_PSIZE ? MAX_PSIZE : len;
  123. }
  124.  
  125. // copy operator
  126. xcmdString::xcmdString( xcmdString& s )
  127. { 
  128.     len = s.length();
  129.     str = new char[len+2];
  130.         ThrowIfNil_( str );
  131.     // copy strlen pointer and all.
  132.     strncpy( str, (char*)s.pStr(), len+2 );
  133. }
  134.  
  135. // from c string
  136. xcmdString::xcmdString( char* s )
  137. { 
  138.     len = strlen(s);
  139.     str = new char[len+2];
  140.         ThrowIfNil_( str );
  141.     strcpy( cStr(), s );
  142.     str[0] = len>MAX_PSIZE ? MAX_PSIZE : len;
  143.     str[len+1]    = '\0';    // null terminate
  144. }
  145.  
  146. // from pointer
  147. xcmdString::xcmdString( char* s, long n )
  148. { 
  149.     len = n;
  150.     str = new char[len+2];
  151.         ThrowIfNil_( str );
  152.     strncpy( cStr(), s, n );
  153.     str[0] = len>MAX_PSIZE ? MAX_PSIZE : len;
  154.     str[len+1]    = '\0';    // null terminate
  155. }
  156.  
  157. // from pascal string
  158. xcmdString::xcmdString( StringPtr s )
  159. { 
  160.     len = s[0];
  161.     str = new char[len+2];
  162.         ThrowIfNil_( str );
  163.     strncpy( str, (char*)s, len+1 );
  164.     str[len+1]    = '\0';    // null terminate
  165. }
  166.  
  167. /****  String Conversions  ****/
  168. xcmdString::xcmdString( Boolean bool )
  169. {
  170.     str = new char[8];
  171.         ThrowIfNil_( str );
  172.     
  173.     BoolToStr( paramPtr, bool, StringPtr(str) );
  174.     len = str[0];
  175.     str[len+1]    = '\0';    // null terminate
  176. }
  177.  
  178. xcmdString::xcmdString( double_t num )
  179. {
  180.     str = new char[20];
  181.         ThrowIfNil_( str );
  182.  
  183.     Double_tToStr( paramPtr, num, StringPtr(str) ); 
  184.     len = str[0];
  185.     str[len+1]    = '\0';    // null terminate
  186. }
  187.  
  188. xcmdString::xcmdString( unsigned long posNum )
  189. {
  190.     str = new char[20];
  191.         ThrowIfNil_( str );
  192.  
  193.     LongToStr( paramPtr, long(posNum), StringPtr(str) ); 
  194.     len = str[0];
  195.     str[len+1]    = '\0';    // null terminate
  196. }
  197.  
  198. xcmdString::xcmdString( long num, short nd )
  199. {
  200.     str = new char[nd+4];
  201.         ThrowIfNil_( str );
  202.  
  203.     NumToHex( paramPtr, num, nd, StringPtr(str) );
  204.     len = str[0];
  205.     str[len+1]    = '\0';    // null terminate
  206. }
  207.  
  208. xcmdString::xcmdString( long num )
  209. {
  210.     str = new char[20];
  211.         ThrowIfNil_( str );
  212.  
  213.     NumToStr( paramPtr, num, StringPtr(str) ); 
  214.     len = str[0];
  215.     str[len+1]    = '\0';    // null terminate
  216. }
  217.  
  218. xcmdString::xcmdString( Point pt )
  219. {
  220.     str = new char[15];
  221.         ThrowIfNil_( str );
  222.  
  223.     PointToStr( paramPtr, pt, StringPtr(str) );
  224.     len = str[0];
  225.     str[len+1]    = '\0';    // null terminate
  226. }
  227.  
  228. xcmdString::xcmdString( Rect& rct )
  229. {
  230.     str = new char[30];
  231.         ThrowIfNil_( str );
  232.  
  233.     RectToStr( paramPtr, &rct, StringPtr(str) ); 
  234.     len = str[0];
  235.     str[len+1]    = '\0';    // null terminate
  236. }
  237.  
  238. #pragma    mark -
  239. #pragma    mark • Operators…
  240. // conversion operators for useful types:
  241. xcmdString::operator Boolean() const
  242. {
  243.     Boolean rc = StrToBool( paramPtr, StringPtr(str) );
  244.     return rc;
  245. }
  246.  
  247. xcmdString::operator Rect() const
  248. {
  249.         Rect    rct;
  250.     StrToRect( paramPtr, StringPtr(str), &rct );
  251.     return rct;
  252. }
  253.  
  254. xcmdString::operator Point() const
  255. {
  256.         Point    pt;
  257.     StrToPoint( paramPtr, pStr(), &pt );
  258.     return pt;
  259. }
  260.  
  261. xcmdString::operator double_t() const
  262. {
  263.     double_t e = StrToDouble_t( paramPtr, pStr() ); 
  264.     return e;
  265. }
  266.  
  267. xcmdString::operator unsigned long() const
  268. {
  269.     unsigned long d = StrToLong( paramPtr, pStr() ); 
  270.     return d;
  271. }
  272.  
  273. xcmdString::operator long() const
  274. {
  275.     unsigned long d = StrToNum( paramPtr, pStr() ); 
  276.     return d;
  277. }
  278.  
  279. xcmdString::operator StringPtr() const
  280. {
  281.     return pStr();
  282. }
  283.  
  284. xcmdString::operator char*() const
  285. {
  286.     return cStr();
  287. }
  288.  
  289. // I create a handle, copy data, hand it off. You must manage it!
  290. xcmdString::operator Handle() const
  291. {
  292.     Handle h;
  293.     
  294.     h = NewHandleClear (length() + 1);
  295.     if ( h )
  296.         strcpy( (char *) *h, cStr() );
  297.     
  298.     return h;
  299. }
  300.  
  301. #pragma    mark -
  302. #pragma mark • Testing operations…
  303. // Some key testing operators. == != contains
  304. //    ____________________________________
  305. long            
  306. xcmdString::contains( const xcmdString& s2 ) const
  307. {
  308.     char*    op    =    (char*)StringMatch( paramPtr, s2, cStr() );
  309.     if ( op == nil ) return 0;
  310.     return op-str;
  311. }
  312.  
  313. Boolean
  314. operator!=( const xcmdString& s1, const xcmdString& s2 )
  315. {
  316.     Boolean    rc    =    StringEqual( xcmdString::paramPtr, s1.pStr(), s2.pStr() );
  317.     return !rc;
  318. }
  319.  
  320. // Equate.  Is a friend so that "" clauses are handled automaticlly
  321. //    ____________________________________
  322. Boolean
  323. operator==( const xcmdString& s1, const xcmdString& s2 )
  324. {
  325.     Boolean    rc    =    StringEqual( xcmdString::paramPtr, s1.pStr(), s2.pStr() );
  326.     return rc;
  327. }
  328.  
  329. // overloading of assignment.
  330. //    ____________________________________
  331. xcmdString&
  332. xcmdString::operator=( const xcmdString& s2 )
  333. {
  334.     if ( this != &s2 ) {
  335.         if ( str != nil )    delete [] str;
  336.         len =  s2.length();
  337.         str = new char[len+2];
  338.             ThrowIfNil_( str );
  339.         // copy strlen pointer and all.
  340.         strncpy( str, (char*)s2.pStr(), len+2 );
  341.         }
  342.     return *this;
  343. }
  344.  
  345. xcmdString&
  346. xcmdString::operator&=( const xcmdString& s2 )
  347. {
  348.     char*    temp    =    str;
  349.  
  350.     len +=  s2.length();
  351.     str = new char[len+2];
  352.         ThrowIfNil_( str );
  353.  
  354.     if ( temp != nil ) {
  355.         strcpy( cStr(), &temp[1] );
  356.         delete [] temp;
  357.         }
  358.     
  359.     strcat( cStr(), s2.cStr() );
  360.     
  361.     str[0] = len>MAX_PSIZE ? MAX_PSIZE : len;
  362.  
  363.     return *this;
  364. }
  365.  
  366. // overloading of index to return specific element.
  367. //    ____________________________________
  368. char
  369. xcmdString::operator[]( const int i )
  370. {
  371.     if ( i>length() ) return '\0';
  372.     return cStr()[i];
  373. }
  374.  
  375. // Catenation.  Is a friend so that "" are handled automaticlly
  376. //    ____________________________________
  377. xcmdString
  378. operator&( const xcmdString& s1, const xcmdString& s2 )
  379. {
  380.     char*    s    =    new    char[ s1.length() + s2.length() + 2 ];
  381.         ThrowIfNil_( s );
  382.     strcpy( s, s1.cStr() );
  383.     xcmdString    rs( strcat( s, s2.cStr() ) );
  384.     delete [] s;
  385.     return rs;
  386. }
  387.  
  388. #pragma    mark -
  389. #pragma mark • Conditioning operations…
  390. void
  391. xcmdString::trimWhiteSpace( void )
  392. {
  393.     char*    sp    =    cStr();
  394.     
  395.     while( *sp == ' ' || *sp == '\t' || *sp == '\r' ) sp++;
  396.  
  397.     ::BlockMove( sp, cStr(), length() );
  398.     
  399.     len = strlen(cStr());
  400.     while( str[len] == ' ' || str[len] == '\t' || str[len] == '\r' ) len--;
  401.  
  402.     str[0] = len>MAX_PSIZE ? MAX_PSIZE : len;
  403.     str[len+1]    = '\0';    // null terminate
  404.  
  405. }
  406.  
  407.